const express = require('express');
const router = express.Router();
const fs = require('fs').promises;
const path = require('path');

// 角色数据存储路径
const ROLES_DATA_PATH = path.join(__dirname, '../data/roles');

// 确保角色数据目录存在
async function ensureRolesDirectory() {
  try {
    await fs.access(ROLES_DATA_PATH);
  } catch {
    await fs.mkdir(ROLES_DATA_PATH, { recursive: true });
  }
}

// 获取用户角色数据文件路径
function getUserRolesPath(userId) {
  return path.join(ROLES_DATA_PATH, `${userId}.json`);
}

// 验证用户身份的中间件
async function authenticateUser(req, res, next) {
  try {
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        success: false,
        error: '未提供认证Token'
      });
    }

    const token = authHeader.substring(7);
    // 导入 auth.js 中的 verifyToken 函数
    const { verifyToken } = require('./auth');
    const userId = verifyToken(token);
    
    if (!userId) {
      return res.status(401).json({
        success: false,
        error: 'Token无效或已过期'
      });
    }

    req.userId = userId;
    next();
  } catch (error) {
    console.error('身份验证失败:', error);
    res.status(500).json({
      success: false,
      error: '服务器错误'
    });
  }
}

// 获取用户的自定义角色
router.get('/user-roles', authenticateUser, async (req, res) => {
  try {
    await ensureRolesDirectory();
    
    const userId = req.userId;
    const userRolesPath = getUserRolesPath(userId);
    
    console.log(`获取用户 ${userId} 的角色数据`);
    
    try {
      const rolesData = await fs.readFile(userRolesPath, 'utf8');
      const roles = JSON.parse(rolesData);
      
      console.log(`成功加载用户 ${userId} 的 ${roles.length} 个角色`);
      
      res.json({
        success: true,
        data: {
          roles,
          count: roles.length,
          lastUpdated: (await fs.stat(userRolesPath)).mtime
        }
      });
    } catch (error) {
      if (error.code === 'ENOENT') {
        // 用户还没有自定义角色数据
        console.log(`用户 ${userId} 还没有自定义角色数据`);
        res.json({
          success: true,
          data: {
            roles: [],
            count: 0,
            lastUpdated: null
          }
        });
      } else {
        throw error;
      }
    }
  } catch (error) {
    console.error('获取用户角色失败:', error);
    res.status(500).json({
      success: false,
      error: '获取角色数据失败'
    });
  }
});

// 保存用户的自定义角色
router.post('/user-roles', authenticateUser, async (req, res) => {
  try {
    await ensureRolesDirectory();
    
    const userId = req.userId;
    const { roles } = req.body;
    
    if (!Array.isArray(roles)) {
      return res.status(400).json({
        success: false,
        error: '角色数据必须是数组格式'
      });
    }
    
    console.log(`保存用户 ${userId} 的 ${roles.length} 个角色`);
    
    // 验证角色数据格式 - 只检查基本必需字段，保留完整数据
    const validatedRoles = roles.filter(role => {
      const isValid = role && typeof role === 'object' && role.id && role.name;
      if (!isValid) {
        console.warn('过滤无效角色:', { id: role?.id, name: role?.name, hasAbility: !!role?.ability, hasImage: !!role?.image });
      } else {
        console.log(`✅ 保存角色 ${role.id}: 图片=${!!role.image}, 能力=${!!role.ability}, 完整字段数=${Object.keys(role).length}`);
      }
      return isValid;
    });
    
    if (validatedRoles.length !== roles.length) {
      console.warn(`过滤掉 ${roles.length - validatedRoles.length} 个无效角色`);
    }
    
    const userRolesPath = getUserRolesPath(userId);
    await fs.writeFile(userRolesPath, JSON.stringify(validatedRoles, null, 2), 'utf8');
    
    console.log(`成功保存用户 ${userId} 的 ${validatedRoles.length} 个角色到服务器`);
    
    res.json({
      success: true,
      data: {
        count: validatedRoles.length,
        saved: validatedRoles.length,
        filtered: roles.length - validatedRoles.length,
        timestamp: new Date().toISOString()
      },
      message: `成功保存 ${validatedRoles.length} 个角色到服务器`
    });
  } catch (error) {
    console.error('保存用户角色失败:', error);
    res.status(500).json({
      success: false,
      error: '保存角色数据失败'
    });
  }
});

// 添加角色到用户收藏（从导入操作）
router.post('/user-roles/import', authenticateUser, async (req, res) => {
  try {
    await ensureRolesDirectory();
    
    const userId = req.userId;
    const { roles, operation = 'merge' } = req.body; // merge | replace
    
    if (!Array.isArray(roles)) {
      return res.status(400).json({
        success: false,
        error: '导入的角色数据必须是数组格式'
      });
    }
    
    console.log(`用户 ${userId} 导入 ${roles.length} 个角色，操作类型: ${operation}`);
    
    const userRolesPath = getUserRolesPath(userId);
    let existingRoles = [];
    
    // 如果是合并操作，先加载现有角色
    if (operation === 'merge') {
      try {
        const existingData = await fs.readFile(userRolesPath, 'utf8');
        existingRoles = JSON.parse(existingData);
        console.log(`加载现有 ${existingRoles.length} 个角色`);
      } catch (error) {
        if (error.code !== 'ENOENT') {
          throw error;
        }
        // 文件不存在，继续处理
      }
    }
    
    // 验证和清理导入的角色数据
    const validatedRoles = roles.filter(role => {
      return role && typeof role === 'object' && role.id && role.name && role.ability;
    }).map(role => ({
      ...role,
      id: role.id.toLowerCase().replace(/[^a-z0-9]/g, ""), // 清理ID
      isCustom: true,
      roleType: role.roleType || 'custom',
      importedAt: new Date().toISOString()
    }));
    
    let finalRoles;
    let stats = {
      imported: 0,
      skipped: 0,
      updated: 0
    };
    
    if (operation === 'replace') {
      // 替换操作：直接使用新角色
      finalRoles = validatedRoles;
      stats.imported = validatedRoles.length;
    } else {
      // 合并操作：去重合并
      const roleMap = new Map();
      
      // 先添加现有角色
      existingRoles.forEach(role => {
        roleMap.set(role.id, role);
      });
      
      // 添加/更新导入的角色
      validatedRoles.forEach(role => {
        if (roleMap.has(role.id)) {
          roleMap.set(role.id, { ...roleMap.get(role.id), ...role });
          stats.updated++;
        } else {
          roleMap.set(role.id, role);
          stats.imported++;
        }
      });
      
      finalRoles = Array.from(roleMap.values());
      stats.skipped = roles.length - validatedRoles.length;
    }
    
    // 保存到服务器
    await fs.writeFile(userRolesPath, JSON.stringify(finalRoles, null, 2), 'utf8');
    
    console.log(`导入完成: 导入 ${stats.imported} 个, 更新 ${stats.updated} 个, 跳过 ${stats.skipped} 个`);
    
    res.json({
      success: true,
      data: {
        totalRoles: finalRoles.length,
        ...stats,
        timestamp: new Date().toISOString()
      },
      message: `导入完成！导入 ${stats.imported} 个角色，更新 ${stats.updated} 个角色，跳过 ${stats.skipped} 个无效角色`
    });
  } catch (error) {
    console.error('导入用户角色失败:', error);
    res.status(500).json({
      success: false,
      error: '导入角色数据失败'
    });
  }
});

// 删除用户的特定角色
router.delete('/user-roles/:roleId', authenticateUser, async (req, res) => {
  try {
    const userId = req.userId;
    const { roleId } = req.params;
    
    const userRolesPath = getUserRolesPath(userId);
    
    try {
      const rolesData = await fs.readFile(userRolesPath, 'utf8');
      const roles = JSON.parse(rolesData);
      
      const originalCount = roles.length;
      const filteredRoles = roles.filter(role => role.id !== roleId);
      
      if (filteredRoles.length === originalCount) {
        return res.status(404).json({
          success: false,
          error: '角色不存在'
        });
      }
      
      await fs.writeFile(userRolesPath, JSON.stringify(filteredRoles, null, 2), 'utf8');
      
      console.log(`用户 ${userId} 删除角色 ${roleId}`);
      
      res.json({
        success: true,
        data: {
          deletedRoleId: roleId,
          remainingCount: filteredRoles.length
        },
        message: '角色删除成功'
      });
    } catch (error) {
      if (error.code === 'ENOENT') {
        return res.status(404).json({
          success: false,
          error: '用户没有自定义角色数据'
        });
      }
      throw error;
    }
  } catch (error) {
    console.error('删除用户角色失败:', error);
    res.status(500).json({
      success: false,
      error: '删除角色失败'
    });
  }
});

// 清空用户的所有自定义角色
router.delete('/user-roles', authenticateUser, async (req, res) => {
  try {
    const userId = req.userId;
    const userRolesPath = getUserRolesPath(userId);
    
    try {
      await fs.unlink(userRolesPath);
      console.log(`清空用户 ${userId} 的所有角色数据`);
      
      res.json({
        success: true,
        message: '已清空所有自定义角色'
      });
    } catch (error) {
      if (error.code === 'ENOENT') {
        res.json({
          success: true,
          message: '用户没有自定义角色数据，无需清空'
        });
      } else {
        throw error;
      }
    }
  } catch (error) {
    console.error('清空用户角色失败:', error);
    res.status(500).json({
      success: false,
      error: '清空角色数据失败'
    });
  }
});

module.exports = router;